﻿/**
 * @file std_hash.h
 * Copyright (c) 2019 Gaaagaa. All rights reserved.
 * 
 * @author  : Gaaagaa
 * @date    : 2019-09-09
 * @version : 1.0.0.0
 * @brief   : 使用 C API 的接口形式实现 散列 容器。
 */

/**
 * The MIT License (MIT)
 * Copyright (c) Gaaagaa. All rights reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is furnished to do
 * so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef __STD_HASH_H__
#define __STD_HASH_H__

#include "std_comm.h"

////////////////////////////////////////////////////////////////////////////////

#ifdef __cplusplus
extern "C"
{
#endif // __cplusplus

////////////////////////////////////////////////////////////////////////////////

//====================================================================

// 
// xstd_hash_t 的相关数据类型定义
// 

#define XHASH_FALSE  XSTD_FALSE
#define XHASH_TRUE   XSTD_TRUE
#define XHASH_NULL   XSTD_NULL

typedef xstd_void_t  xhash_void_t;
typedef xstd_bool_t  xhash_bool_t;
typedef xstd_size_t  xhash_size_t;
typedef xstd_float_t xhash_float_t;
typedef xstd_elem_t  xhash_elem_t;
typedef xstd_size_t  xhash_nkey_t;
typedef xstd_mptr_t  xhash_mptr_t;
typedef xstd_ctxt_t  xhash_ctxt_t;

/** 计算 散列键值 的函数类型 */
typedef xstd_func_hash_t xhash_nkfunc_t;

/** 声明 节点元素 判断相等操作 的函数类型 */
typedef xstd_func_compare_t xhash_eqfunc_t;

/** 声明 xstd_hash_t 对象指针类型 */
typedef struct xstd_hash_t * xhash_this_t;

/** 声明 xstd_hash_t 的迭代器类型 */
typedef xstd_handle_t  xhash_iter_t;

//====================================================================

// 
// xstd_hash_t 的相关操作接口
// 

/**********************************************************/
/**
 * @brief 返回内部的 sizeof(xstd_hash_t) 值。
 */
xhash_size_t std_hash_sizeof(void);

/**********************************************************/
/**
 * @brief 计算 指定缓存块数据 的 散列键值。
 * 
 * @param [in ] xhash_mptr : 指定的缓存块数据。
 * @param [in ] xst_msize  : 指定的缓存块大小。
 * 
 * @return xhash_nkey_t : 返回 散列键值。
 */
xhash_nkey_t std_hash_nkey_calc(xhash_mptr_t xhash_mptr, xhash_size_t xst_msize);

/**********************************************************/
/**
 * @brief 创建 xstd_hash_t 对象。
 * @note 
 * 1. 应使用 @see std_hash_destroy() 销毁所创建的对象。
 * 2. 若 xhash_nkfunc/xhash_eqfunc 为 XHASH_NULL，则取内部默认值。
 * 
 * @param [in ] xhash_ctxt   : 散列 所存储的节点元素上下文描述信息。
 * @param [in ] xhash_nkfunc : 生成 散列键值 的回调函数。
 * @param [in ] xhash_eqfunc : 判断 节点元素是否相等 的回调函数。
 * 
 * @return xhash_this_t : 返回所创建的 xstd_hash_t 对象指针。
 */
xhash_this_t std_hash_create(
                    xhash_ctxt_t xhash_ctxt,
                    xhash_nkfunc_t xhash_nkfunc,
                    xhash_eqfunc_t xhash_eqfunc);

/**********************************************************/
/**
 * @brief 
 * 销毁 xstd_hash_t 对象，
 * 其由 @see std_hash_create() 接口所创建。
 */
xhash_void_t std_hash_destroy(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 在指定的缓存上创建 xstd_hash_t 对象。
 * @note 
 * 1. 应使用 @see std_hash_destroy() 销毁所创建的对象。
 * 2. 若 xhash_nkfunc/xhash_eqfunc 为 XHASH_NULL，则取内部默认值。
 * 
 * @param [in ] xhash_ctxt   : 散列 所存储的节点元素上下文描述信息。
 * @param [in ] xhash_nkfunc : 生成 散列键值 的回调函数。
 * @param [in ] xhash_eqfunc : 判断 节点元素是否相等 的回调函数。
 * 
 * @return xhash_this_t : 返回所创建的 xstd_hash_t 对象指针。
 */
xhash_this_t std_hash_emplace_create(
                    xhash_this_t xhash_this,
                    xhash_ctxt_t xhash_ctxt,
                    xhash_nkfunc_t xhash_nkfunc,
                    xhash_eqfunc_t xhash_eqfunc);

/**********************************************************/
/**
 * @brief 
 * 销毁 xstd_hash_t 对象，
 * 其由 @see std_hash_emplace_create() 接口所创建。
 */
xhash_void_t std_hash_emplace_destroy(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的 上下文信息。
 */
xhash_ctxt_t std_hash_ctxt(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的 类型标识。
 */
xhash_size_t std_hash_etype(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象当前的节点数量。
 */
xhash_size_t std_hash_size(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 判断 xstd_hash_t 对象是否为空。
 */
xhash_bool_t std_hash_empty(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象可容纳最大的节点数量。
 */
xhash_size_t std_hash_maxsize(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 清除 xstd_hash_t 对象中的所有节点。
 */
xhash_void_t std_hash_clear(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 向 xstd_hash_t 对象插入（存入）新的 节点元素。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * @param [in    ] xhash_elem : 插入（存入）新的 节点元素对象。
 * 
 * @param [out   ] xbt_clash  : 
 * 检测所插入的 新节点键值 是否与 xstd_hash_t 对象中
 * 原有的 节点键值 是否冲突。
 * 入参不为 XHASH_NULL 时，
 *  若返回值为 XHASH_TRUE，表示产生冲突，插入操作算是失败的；
 *  否则，返回 XHASH_FALSE，表示产生冲突，插入操作
 *  算是（新增节点）成功的。
 * 入参为 XHASH_NULL 时，则忽略该检测操作。
 * 
 * @return xhash_iter_t : 返回 xhash_elem 散列键值的对应节点。
 */
xhash_iter_t std_hash_insert(
                xhash_this_t xhash_this,
                xhash_elem_t xhash_elem,
                xhash_bool_t * xbt_clash);

/**********************************************************/
/**
 * @brief 向 xstd_hash_t 对象安放（存入）新的 节点元素。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * 
 * @param [in    ] xhash_elem : 
 * 安放（存入）新的 节点元素对象（使用 右值move 操作进行存储）。
 * 
 * @param [out   ] xbt_clash  : 
 * 检测所插入的 新节点键值 是否与 xstd_hash_t 对象中
 * 原有的 节点键值 是否冲突。
 * 入参不为 XHASH_NULL 时，
 *  若返回值为 XHASH_TRUE，表示产生冲突，安放操作算是失败的；
 *  否则，返回 XHASH_FALSE，表示产生冲突，安放操作
 *  算是（新增节点）成功的。
 * 入参为 XHASH_NULL 时，则忽略该检测操作。
 * 
 * @return xhash_iter_t : 返回 xhash_elem 散列键值的对应节点。
 */
xhash_iter_t std_hash_emplace(
                xhash_this_t xhash_this,
                xhash_elem_t xhash_elem,
                xhash_bool_t * xbt_clash);

/**********************************************************/
/**
 * @brief 删除 xstd_hash_t 对象中的指定（迭代器对应的）节点元素。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * @param [in    ] xiter_pos  : 所要删除的节点（迭代器）。
 * 
 * @return xhash_iter_t : 返回 xiter_pos 的后继节点。
 */
xhash_iter_t std_hash_erase(
                xhash_this_t xhash_this,
                xhash_iter_t xiter_pos);

/**********************************************************/
/**
 * @brief 删除 xstd_hash_t 对象中的指定节点元素值。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * @param [in    ] xhash_elem : 所要删除的节点（迭代器）。
 * 
 * @return xhash_size_t : 删除的节点数量（0 或 1）。
 */
xhash_size_t std_hash_erase_elem(
                xhash_this_t xhash_this,
                xhash_elem_t xhash_elem);

/**********************************************************/
/**
 * @brief 
 * 删除 xstd_hash_t 对象中的指定
 * 区间 [ xiter_first, xiter_last ) 节点元素。
 * 
 * @param [in,out] xhash_this  : xstd_hash_t 对象。
 * @param [in    ] xiter_first : 所删除区间的起始节点。
 * @param [in    ] xiter_last  : 所删除区间的结束节点。
 * 
 * @return xhash_iter_t : 返回 xiter_last 节点。
 */
xhash_iter_t std_hash_erase_range(
                xhash_this_t xhash_this,
                xhash_iter_t xiter_first,
                xhash_iter_t xiter_last);

/**********************************************************/
/**
 * @brief 
 * 将 xhash_other 中的 节点元素 转移到 xhash_this 中。
 * @note 
 * 若 xhash_other 中的 某个节点元素，在 xhash_this 中有相同的值，
 * 则不对该节点元素进行转移操作，依然会保留在原来的 xhash_other 中。
 * 
 * @param [in,out] xhash_this  : 接收 转移节点元素 的 xstd_hash_t 对象。
 * @param [in,out] xhash_other : 被移出 节点元素 的 xstd_hash_t 对象。
 */
xhash_void_t std_hash_merge(
                xhash_this_t xhash_this,
                xhash_this_t xhash_other);

/**********************************************************/
/**
 * @brief 
 * 统计 xstd_hash_t 对象中，
 * 为 xhash_elem 节点元素值的数量（0 或 1）。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * @param [in    ] xhash_elem : 所统计的节点元素值。
 * 
 * @return xhash_size_t : 统计到的数量（0 或 1）。
 */
xhash_size_t std_hash_count(
                xhash_this_t xhash_this,
                xhash_elem_t xhash_elem);

/**********************************************************/
/**
 * @brief 
 * 查找 xstd_hash_t 对象中，
 * 为 xhash_elem 节点元素值的迭代器位置。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * @param [in    ] xhash_elem : 所查找的节点元素值。
 * 
 * @return xhash_iter_t : 
 * 所查找的节点元素迭代器位置，
 * 或为 std_hash_end(xhash_this) 末端迭代器。
 */
xhash_iter_t std_hash_find(
                xhash_this_t xhash_this,
                xhash_elem_t xhash_elem);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的当前散列桶数量。
 */
xhash_size_t std_hash_bucket_count(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的散列桶最大容纳数量。
 */
xhash_size_t std_hash_bucket_maxcount(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 计算 节点元素 对象在 xstd_hash_t 对象中的 散列键值。
 * 
 * @param [in ] xhash_this : xstd_hash_t 对象。
 * @param [in ] xhash_elem : 节点元素值。
 * 
 * @return xhash_nkey_t : 散列键值。
 */
xhash_nkey_t std_hash_bucket_nkey(
                xhash_this_t xhash_this,
                xhash_elem_t xhash_elem);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象指定 散列桶 中当前存储的节点数量。
 * 
 * @param [in ] xhash_this : xstd_hash_t 对象。
 * @param [in ] xhash_nkey : 所指定的 散列桶索引键值。
 * 
 * @return xhash_size_t : 指定 散列桶 中当前存储的节点数量。
 */
xhash_size_t std_hash_bucket_size(
                xhash_this_t xhash_this,
                xhash_nkey_t xhash_nkey);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象指定 散列桶 所存储节点的起始迭代器。
 * 
 * @param [in ] xhash_this : xstd_hash_t 对象。
 * @param [in ] xhash_nkey : 所指定的 散列桶索引键值。
 * 
 * @return xhash_iter_t : 指定 散列桶 所存储节点的起始迭代器。
 */
xhash_iter_t std_hash_bucket_begin(
                xhash_this_t xhash_this,
                xhash_nkey_t xhash_nkey);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象指定 散列桶 所存储节点的结束迭代器。
 * 
 * @param [in ] xhash_this : xstd_hash_t 对象。
 * @param [in ] xhash_nkey : 所指定的 散列桶索引键值。
 * 
 * @return xhash_iter_t : 指定 散列桶 所存储节点的结束迭代器。
 */
xhash_iter_t std_hash_bucket_end(
                xhash_this_t xhash_this,
                xhash_nkey_t xhash_nkey);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象当前的 散列桶负载率。
 * @note  散列桶负载率 = std_hash_size() / std_hash_bucket_count() 。
 */
xhash_float_t std_hash_load_factor(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 
 * 返回 xstd_hash_t 对象的 散列桶最大负载率（max load factor），
 * 其默认值为 1.0F 。
 */
xhash_float_t std_hash_maxlf(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 
 * 设置 xstd_hash_t 对象的 散列桶最大负载率（max load factor）。
 * @note 
 * 所设置的 xft_maxlf 值，要求 ((xft_maxlf > 0) && (NAN != xft_maxlf))。
 */
xhash_void_t std_hash_set_maxlf(
                xhash_this_t xhash_this,
                xhash_float_t xft_maxlf);

/**********************************************************/
/**
 * @brief 设置 xstd_hash_t 对象的 散列桶数量，并重新调整 散列容器。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * @param [in    ] xst_count  : 所设置的散列桶数量。
 */
xhash_void_t std_hash_rehash(
                xhash_this_t xhash_this,
                xhash_size_t xst_count);

/**********************************************************/
/**
 * @brief 预定 xstd_hash_t 对象的节点元素 容量，并重新调整 散列容器。
 * 
 * @param [in,out] xhash_this : xstd_hash_t 对象。
 * @param [in    ] xst_count  : 所设置的 节点元素 容量。
 */
xhash_void_t std_hash_reserve(
                xhash_this_t xhash_this,
                xhash_size_t xst_count);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的起始节点迭代器。
 */
xhash_iter_t std_hash_begin(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 迭代器 的后继节点迭代器。
 */
xhash_iter_t std_hash_next(xhash_iter_t xiter_trav);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的结束节点迭代器。
 */
xhash_iter_t std_hash_end(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的反向起始节点迭代器。
 */
xhash_iter_t std_hash_rbegin(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 返回 反向迭代器 的后继节点迭代器。
 */
xhash_iter_t std_hash_rnext(xhash_iter_t xiter_trav);

/**********************************************************/
/**
 * @brief 返回 xstd_hash_t 对象的反向结束节点迭代器。
 */
xhash_iter_t std_hash_rend(xhash_this_t xhash_this);

/**********************************************************/
/**
 * @brief 读取节点迭代器下存储的 元素。
 */
xhash_elem_t std_hash_elem(xhash_iter_t xiter_node);

////////////////////////////////////////////////////////////////////////////////

/** 
 * @brief 
 * 为 xstd_hash_t 的基础 浮点型 数据容器，
 * 定义简化版散列值计算接口的宏。
 */
#define XSTD_HASH_NKEY_FLOAT_FUNC(xtype, xname, kzero)  \
                                                        \
static inline xhash_nkey_t                              \
    std_hash_nkey_##xname(xtype xhash_elem)             \
{                                                       \
    xhash_elem =                                        \
        (xhash_elem == kzero) ? kzero : xhash_elem;     \
    return std_hash_nkey_calc(                          \
                &xhash_elem,                            \
                sizeof(xtype));                         \
}

XSTD_HASH_NKEY_FLOAT_FUNC(xstd_float_t  , float  , 0.0F)  // 对应 xstd_float_t   类型
XSTD_HASH_NKEY_FLOAT_FUNC(xstd_double_t , double , 0.0 )  // 对应 xstd_double_t  类型
XSTD_HASH_NKEY_FLOAT_FUNC(xstd_ldouble_t, ldouble, 0.0L)  // 对应 xstd_ldouble_t 类型

/** 
 * @brief 
 * 为 xstd_hash_t 的基础数据类型容器，
 * 定义简化版散列值计算接口的宏。
 */
#define XSTD_HASH_NKEY_TYPE_FUNC(xtype, xname)          \
                                                        \
static inline xhash_nkey_t                              \
    std_hash_nkey_##xname(xtype xhash_elem)             \
{                                                       \
    return std_hash_nkey_calc(                          \
                &xhash_elem,                            \
                sizeof(xtype));                         \
}

//====================================================================

XSTD_HASH_NKEY_TYPE_FUNC(xstd_char_t  , char  )  // 对应 xstd_char_t   类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_uchar_t , uchar )  // 对应 xstd_uchar_t  类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_int8_t  , int8  )  // 对应 xstd_int8_t   类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_int16_t , int16 )  // 对应 xstd_int16_t  类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_int32_t , int32 )  // 对应 xstd_int32_t  类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_int64_t , int64 )  // 对应 xstd_int64_t  类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_uint8_t , uint8 )  // 对应 xstd_uint8_t  类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_uint16_t, uint16)  // 对应 xstd_uint16_t 类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_uint32_t, uint32)  // 对应 xstd_uint32_t 类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_uint64_t, uint64)  // 对应 xstd_uint64_t 类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_long_t  , long  )  // 对应 xstd_long_t   类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_llong_t , llong )  // 对应 xstd_llong_t  类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_ulong_t , ulong )  // 对应 xstd_ulong_t  类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_ullong_t, ullong)  // 对应 xstd_ullong_t 类型
XSTD_HASH_NKEY_TYPE_FUNC(xstd_handle_t, handle)  // 对应 xstd_handle_t 类型

////////////////////////////////////////////////////////////////////////////////

/** 
 * @brief 
 * 为 xstd_hash_t 的基础数据类型容器，
 * 定义简化版操作接口的宏。
 */
#define XSTD_HASH_TYPE_FUNC(xtype, xname)               \
                                                        \
static inline xstd_size_t                               \
    std_hash_nkey_calc_##xname(                         \
        xstd_elem_t xet_vptr,                           \
        xstd_ctxt_t xet_ctxt)                           \
{                                                       \
    return std_hash_nkey_##xname(                       \
                *(xtype *)xet_vptr);                    \
}                                                       \
                                                        \
static inline xhash_this_t                              \
    std_hash_create_##xname(void)                       \
{                                                       \
    return std_hash_create(                             \
                &xstd_ctxt_##xname,                     \
                std_hash_nkey_calc_##xname,             \
                xstd_fcmp_##xname.xfunc_eq);            \
}                                                       \
                                                        \
static inline xhash_iter_t                              \
    std_hash_insert_##xname(                            \
        xhash_this_t xhash_this,                        \
        xtype xhash_elem)                               \
{                                                       \
    return std_hash_insert(                             \
                xhash_this,                             \
                &xhash_elem,                            \
                XHASH_NULL);                            \
}                                                       \
                                                        \
static inline xhash_size_t                              \
    std_hash_erase_##xname(                             \
        xhash_this_t xhash_this,                        \
        xtype xhash_elem)                               \
{                                                       \
    return std_hash_erase_elem(                         \
                xhash_this,                             \
                &xhash_elem);                           \
}                                                       \
                                                        \
static inline xhash_size_t                              \
    std_hash_count_##xname(                             \
        xhash_this_t xhash_this,                        \
        xtype xhash_elem)                               \
{                                                       \
    return std_hash_count(                              \
                xhash_this,                             \
                &xhash_elem);                           \
}                                                       \
                                                        \
static inline xhash_iter_t                              \
    std_hash_find_##xname(                              \
        xhash_this_t xhash_this,                        \
        xtype xhash_elem)                               \
{                                                       \
    return std_hash_find(                               \
                xhash_this,                             \
                &xhash_elem);                           \
}                                                       \
                                                        \
static inline xhash_nkey_t                              \
    std_hash_bucket_nkey_##xname(                       \
        xhash_this_t xhash_this,                        \
        xtype xhash_elem)                               \
{                                                       \
    return std_hash_bucket_nkey(                        \
                xhash_this,                             \
                &xhash_elem);                           \
}                                                       \
                                                        \
static inline xtype                                     \
    std_hash_elem_##xname(xhash_iter_t xiter_node)      \
{                                                       \
    return *(xtype *)std_hash_elem(xiter_node);         \
}

//====================================================================

XSTD_HASH_TYPE_FUNC(xstd_char_t   , char   )  // 对应 xstd_char_t    类型
XSTD_HASH_TYPE_FUNC(xstd_uchar_t  , uchar  )  // 对应 xstd_uchar_t   类型
XSTD_HASH_TYPE_FUNC(xstd_int8_t   , int8   )  // 对应 xstd_int8_t    类型
XSTD_HASH_TYPE_FUNC(xstd_int16_t  , int16  )  // 对应 xstd_int16_t   类型
XSTD_HASH_TYPE_FUNC(xstd_int32_t  , int32  )  // 对应 xstd_int32_t   类型
XSTD_HASH_TYPE_FUNC(xstd_int64_t  , int64  )  // 对应 xstd_int64_t   类型
XSTD_HASH_TYPE_FUNC(xstd_uint8_t  , uint8  )  // 对应 xstd_uint8_t   类型
XSTD_HASH_TYPE_FUNC(xstd_uint16_t , uint16 )  // 对应 xstd_uint16_t  类型
XSTD_HASH_TYPE_FUNC(xstd_uint32_t , uint32 )  // 对应 xstd_uint32_t  类型
XSTD_HASH_TYPE_FUNC(xstd_uint64_t , uint64 )  // 对应 xstd_uint64_t  类型
XSTD_HASH_TYPE_FUNC(xstd_long_t   , long   )  // 对应 xstd_long_t    类型
XSTD_HASH_TYPE_FUNC(xstd_llong_t  , llong  )  // 对应 xstd_llong_t   类型
XSTD_HASH_TYPE_FUNC(xstd_ulong_t  , ulong  )  // 对应 xstd_ulong_t   类型
XSTD_HASH_TYPE_FUNC(xstd_ullong_t , ullong )  // 对应 xstd_ullong_t  类型
XSTD_HASH_TYPE_FUNC(xstd_float_t  , float  )  // 对应 xstd_float_t   类型
XSTD_HASH_TYPE_FUNC(xstd_double_t , double )  // 对应 xstd_double_t  类型
XSTD_HASH_TYPE_FUNC(xstd_ldouble_t, ldouble)  // 对应 xstd_ldouble_t 类型
XSTD_HASH_TYPE_FUNC(xstd_handle_t , handle )  // 对应 xstd_handle_t  类型

////////////////////////////////////////////////////////////////////////////////

#ifdef __cplusplus
}; // extern "C"
#endif // __cplusplus

////////////////////////////////////////////////////////////////////////////////

#endif // __STD_HASH_H__

